class AuthController < ApplicationController

before_filter :authenticate
skip_before_filter :authenticate, :only => [:login,:logout]

#----------------------------------------------------------------#
# Métodos para adiministração de usuário
#----------------------------------------------------------------#
=begin
Metodo para a lista sem a utilização do Ajax
=end
  def user
    @users = users_paginate(10)
  end
=begin
Metodo para listar a partir de uma solicitação Ajax
=end  
  def user_list
    
    @users = users_paginate(10)
    
    render :update do |page|
      page.replace_html "user_list" , {:partial => 'user_list', :locals => {:ajax => true}}
      page.show "user_list"
      if params[:displayform] == 'none'
        page.hide "user_form"
      end
    end
    
  end
=begin
Método para apresentação do form para a inclusão ou alteração
=end
  def user_form
    
    unless authenticate_check?('(ADM:ALL||AUTH:ALL||(AUTH:VIEW))')
    
      render :update do |page|
        page.replace_html "user_form" , :partial => 'not_permission'
        page.show "user_form"
      end      

    else

      if params[:id]
        @user = User.find(params[:id])
      else
        @user = User.new
      end

      render :update do |page|
        page.replace_html "user_form" , :partial => 'user_form'
        page.show "user_form"
      end      

    end

  end
=begin
Metodo para criação
=end
  def user_create
    
    unless authenticate_check?('(ADM:ALL||AUTH:ALL||(AUTH:VIEW&&AUTH:CREATE))')

      render :update do |page|
        page.replace_html "user_form" , :partial => 'not_permission'
        page.show "user_form"
      end      

    else

      if params[:id]
        @user = User.find(params[:id])
      else
        @user = User.new
      end
      if request.post?
        @user.attributes = params[:user]
        if @user.save
          redirect_to :action => "user_list", :displayform => "none"
        else
          render :update do |page|
            page.replace_html "user_form" , :partial => 'user_form'
            page.show "user_form"
          end
        end
      end
      
    end
    
  end
=begin
Método para alteração
=end  
  def user_alter
    
    unless authenticate_check?('(ADM:ALL||AUTH:ALL||(AUTH:VIEW&&AUTH:MODIFY))')

      render :update do |page|
        page.replace_html "user_form" , :partial => 'not_permission'
        page.show "user_form"
      end      

    else

      @user = User.find(params[:user][:id])
      if request.post?
        @user.attributes = params[:user]
        if @user.save
          redirect_to :action => "user_list", :displayform => "none"
        else
          render :update do |page|
            page.replace_html "user_form" , :partial => 'user_form'
            page.show "user_form"
          end
        end
      end
      
    end
    
  end
=begin
Método para remoção
=end
  def user_remove

    unless authenticate_check?('(ADM:ALL||AUTH:ALL||(AUTH::REMOVE&&AUTH:VIEW))')

      render :update do |page|
        page << "alert('Desculpe, você não tem permissão para remoção.')"
      end

    else

      if params[:id]
        @user = User.find(params[:id])
        if @user.destroy
          redirect_to :action => "user_list", :displayform => "none"
        end
      end     

    end

  end

#----------------------------------------------------------------#
# Métodos para adiministração de capacidades
#----------------------------------------------------------------#

=begin
Metodo para lista sem a utilização de ajax
=end
  def capabilite
    @capabilites = capabilites_paginate(10)
  end
=begin
Método para lista utilizando o ajax
=end  
  def capabilite_list

    @capabilites = capabilites_paginate(10)

    render :update do |page|
      page.replace_html "capabilite_list" , { :partial => 'capabilite_list', :locals => {:ajax => true} }
      page.show "capabilite_list"
      if params[:displayform] == 'none'
        page.hide "capabilite_form"
      end
    end

  end
=begin
Método para apresentação do form para a inclusão ou alteração
=end
  def capabilite_form
    unless authenticate_check?('(ADM:ALL||AUTH:ALL||(AUTH:VIEW))')
    
      render :update do |page|
        page.replace_html "capabilite_form" , :partial => 'not_permission'
        page.show "capabilite_form"
      end      

    else

      if params[:id]
        @capabilite = Capabilite.find(params[:id])
      else
        @capabilite = Capabilite.new
      end

      render :update do |page|
        page.replace_html "capabilite_form" , :partial => 'capabilite_form'
        page.show "capabilite_form"
      end
      
    end
  end
=begin
Método de criação
=end
  def capabilite_create

    unless authenticate_check?('(ADM:ALL||AUTH:ALL||(AUTH:VIEW&&AUTH:CREATE))')
    
      render :update do |page|
        page.replace_html "capabilite_form" , :partial => 'not_permission'
        page.show "capabilite_form"
      end      

    else

      if params[:id]
        @capabilite = Capabilite.find(params[:id])
      else
        @capabilite = Capabilite.new
      end
      if request.post?
        @capabilite.attributes = params[:capabilite]
        if @capabilite.save
          redirect_to :action => "capabilite_list", :displayform => "none"
        else
          render :update do |page|
            page.replace_html "capabilite_form" , :partial => 'capabilite_form'
            page.show "capabilite_form"
          end
        end
      end

    end

  end
=begin
Método para a alteração
=end  
  def capabilite_alter
    
    unless authenticate_check?('(ADM:ALL||AUTH:ALL||(AUTH:VIEW&&AUTH:MODIFY))')
    
      render :update do |page|
        page.replace_html "capabilite_form" , :partial => 'not_permission'
        page.show "capabilite_form"
      end      

    else

      @capabilite = Capabilite.find(params[:capabilite][:id])
      if request.post?
        @capabilite.attributes = params[:capabilite]
        if @capabilite.save
          redirect_to :action => "capabilite_list", :displayform => "none"
        else
          render :update do |page|
            page.replace_html "capabilite_form" , :partial => 'capabilite_form'
            page.show "capabilite_form"
          end
        end
      end

    end
    
  end
=begin
Método para remoção
=end
  def capabilite_remove

    unless authenticate_check?('(ADM:ALL||AUTH:ALL||(AUTH::REMOVE&&AUTH:VIEW))')

      render :update do |page|
        page << "alert('Desculpe, você não tem permissão para remoção.')"
      end

    else

      if params[:id]
        @capabilite = Capabilite.find(params[:id])
        if @capabilite.destroy
          redirect_to :action => "capabilite_list", :displayform => "none"
        end
      end

    end
  end
  
#----------------------------------------------------------------#
# Métodos para adiministração de regras
#----------------------------------------------------------------#
=begin
Metodo para lista sem a utilização de ajax
=end
  def role
    @roles = roles_paginate(10)
  end
=begin
Metodo para lista com utilização de ajax
=end  
  def role_list
    
    @roles = roles_paginate(10)
    
    render :update do |page|
      page.replace_html "role_list" , {:partial => 'role_list', :locals => {:ajax => true}}
      page.show "role_list"
      if params[:displayform] == 'none'
        page.hide "role_form"
      end
    end
    
  end
=begin
Método para apresentação do form para a inclusão ou alteração
=end
  def role_form
    
    unless authenticate_check?('(ADM:ALL||AUTH:ALL||(AUTH:VIEW))')
    
      render :update do |page|
        page.replace_html "role_form" , :partial => 'not_permission'
        page.show "role_form"
      end      

    else

      @capabilites = capabilites_paginate(5)
      if params[:id]
        @role = Role.find(params[:id])
      else
        @role = Role.new
      end
      render :update do |page|
        page.replace_html "role_form" , :partial => 'role_form'
        page.show "role_form"

        for capabilite in @role.capabilites
          page << "Auth.Capabilite.add('#{capabilite[:id]}','#{capabilite[:acronym]}:#{capabilite[:name]}')"
        end
      end
    
    end
    
  end
=begin
Método de criação de regras
=end
  def role_create
    
    unless authenticate_check?('(ADM:ALL||AUTH:ALL||(AUTH:VIEW&&AUTH:CREATE))')
    
      render :update do |page|
        page.replace_html "role_form" , :partial => 'not_permission'
        page.show "role_form"
      end      

    else

      if params[:id]
        @role = Role.find(params[:id])
      else
        @role = Role.new
      end
      if request.post?
        @role.attributes = params[:role]
        @role.capabilite_ids = params[:capabilite_ids].split(',')
        if @role.save
          redirect_to :action => "role_list", :displayform => "none"
        else
          @capabilites = capabilites_paginate(5)
          render :update do |page|
            page.replace_html "role_form" , :partial => 'role_form'
            page.show "role_form"
          end
        end
      end

    end

  end
=begin
Método para a alteração de regras
=end  
  def role_alter

    unless authenticate_check?('(ADM:ALL||AUTH:ALL||(AUTH:VIEW&&AUTH:MODIFY))')
    
      render :update do |page|
        page.replace_html "role_form" , :partial => 'not_permission'
        page.show "role_form"
      end      

    else

      @role = Role.find(params[:role][:id])
      if request.post?
        @role.attributes = params[:role]
        @role.capabilite_ids = params[:capabilite_ids].split(',')
        if @role.save
          redirect_to :action => "role_list", :displayform => "none"
        else
          @capabilites = capabilites_paginate(5)
          render :update do |page|
            page.replace_html "role_form" , :partial => 'role_form'
            page.show "role_form"
          end
        end
      end
      
    end
    
  end
=begin
Método para remoção de regras
=end
  def role_remove
    unless authenticate_check?('(ADM:ALL||AUTH:ALL||(AUTH::REMOVE&&AUTH:VIEW))')

      render :update do |page|
        page << "alert('Desculpe, você não tem permissão para remoção.')"
      end

    else

      if params[:id]
        @role = Role.find(params[:id])
        if @role.destroy
          redirect_to :action => "role_list", :displayform => "none"
        end
      end

    end
    
  end
=begin
Metodp para listar somente as capabilites
=end
  def role_capabilite_list
    @capabilites = capabilites_paginate(5)
    render :update do |page|
      page.replace_html "role_capabilite_list" , :partial => 'role_capabilite_list'
      page.show "role_capabilite_list"
    end
  end

  
#----------------------------------------------------------------#
# Métodos para adiministração de grupos
#----------------------------------------------------------------#
=begin
Metodo para a lista sem utilização de ajax
=end
  def group
    @groups = groups_paginate(10)
  end
=begin
Metodo para lista com utilização de ajax
=end  
  def group_list
    @groups = groups_paginate(10)
    render :update do |page|
      page.replace_html "group_list" , {:partial => 'group_list', :locals => {:ajax => true}}
      page.show "group_list"
      if params[:displayform] == 'none'
        page.hide "group_form"
      end
    end
  end
=begin
Método para apresentação do form para a inclusão ou alteração
=end
  def group_form
    
    unless authenticate_check?('(ADM:ALL||AUTH:ALL||(AUTH:VIEW))')
    
      render :update do |page|
        page.replace_html "group_form" , :partial => 'not_permission'
        page.show "group_form"
      end      

    else
    
      @roles = roles_paginate(5)
      @users = users_paginate(5)
      if params[:id]
        @group = Group.find(params[:id])
      else
        @group = Group.new
      end
      render :update do |page|
        page.replace_html "group_form" , :partial => 'group_form'
        page.show "group_form"
        for role in @group.roles
          page << "Auth.Role.add('#{role[:id]}','#{role[:name]}')"
        end
        for user in @group.users
          page << "Auth.User.add('#{user[:id]}','#{user[:name]}')"
        end
      end
    
    end
    
  end
=begin
Método de criação
=end
  def group_create

    unless authenticate_check?('(ADM:ALL||AUTH:ALL||(AUTH:VIEW&&AUTH:CREATE))')
    
      render :update do |page|
        page.replace_html "group_form" , :partial => 'not_permission'
        page.show "group_form"
      end      

    else

      if params[:id]
        @group = Group.find(params[:id])
      else
        @group = Group.new
      end
      if request.post?
        @group.attributes = params[:group]
        @group.role_ids = params[:role_ids].split(',')
        @group.user_ids = params[:user_ids].split(',')
        if @group.save
          redirect_to :action => "group_list", :displayform => "none"
        else
          @roles = roles_paginate(5)
          @users = users_paginate(5)
          render :update do |page|
            page.replace_html "group_form" , :partial => 'group_form'
            page.show "group_form"
          end
        end
      end
      
    end
    
  end
=begin
Método para a alteração
=end  
  def group_alter
    
    unless authenticate_check?('(ADM:ALL||AUTH:ALL||(AUTH:VIEW&&AUTH:MODIFY))')
    
      render :update do |page|
        page.replace_html "group_form" , :partial => 'not_permission'
        page.show "group_form"
      end      

    else
    
      @group = Group.find(params[:group][:id])
      if request.post?
        @group.attributes = params[:group]
        @group.role_ids = params[:role_ids].split(',')
        @group.user_ids = params[:user_ids].split(',')
        if @group.save
          redirect_to :action => "group_list", :displayform => "none"
        else
          @roles = roles_paginate(5)
          @users = users_paginate(5)
          render :update do |page|
            page.replace_html "group_form" , :partial => 'group_form'
            page.show "group_form"
          end
        end
      end
    
    end
    
  end
=begin
Método para remoção
=end
  def group_remove
    
    unless authenticate_check?('(ADM:ALL||AUTH:ALL||(AUTH::REMOVE&&AUTH:VIEW))')

      render :update do |page|
        page << "alert('Desculpe, você não tem permissão para remoção.')"
      end

    else

      if params[:id]
        @group = Group.find(params[:id])
        if @group.destroy
          redirect_to :action => "group_list", :displayform => "none"
        end
      end

    end

  end
=begin
Metodp para listar somente as capabilites
=end
  def group_capabilite_list
    @capabilites = capabilites_paginate(5)
    render :update do |page|
      page.replace_html "role_capabilite_list" , :partial => 'role_capabilite_list'
      page.show "role_capabilite_list"
    end
  end

  #----------------------------------------------------------------#
  # Métodos de authenticação
  #----------------------------------------------------------------#
  
  def login
  
    logger.debug(params[:email])
    logger.debug(params[:pass])
    user = User.authenticate(params[:email],params[:pass])
    
    if user == -1
      flash[:notice] = "<p>Desculpe, esse usuário está desativado.</p>" 
      flash[:notice] += "<p><a href='/home/confirmation'>Para receber o email de aprovação clique aqui.</a></p>" 
    else
      if user
          session[:user] = user
          flash[:notice] = "Login efetuado com sucesso."
      else 
        flash[:notice] = "Desculpe, e-mail ou senha não confere, tente novamente."
      end
    end
    
    if params[:return]
      redirect_to params[:return]
    else
      redirect_to "/auth"
    end
    
  end

  def logout
    session[:user] = nil
    if params[:return]
      redirect_to params[:return]
    else
      redirect_to "/auth"
    end
  end
  
  protected
  
=begin
Filtro de autenticação do controler
=end
  def authenticate
    authenticate_check('(ADM:ALL||AUTH:VIEW||AUTH:ALL)','/')
  end
  
  
  #----------------------------------------------------------------#
  # Métodos geráis
  #----------------------------------------------------------------#
  
  def capabilites_paginate(pages)
    Capabilite.paginate :order => 'acronym,name', :page => params[:page], :per_page => pages
  end

  def roles_paginate(pages)
    Role.paginate :order => 'name', :page => params[:page], :per_page => pages
  end

  def users_paginate(pages)
    User.paginate :order => 'name', :page => params[:page], :per_page => pages
  end
  
  def groups_paginate(pages)
    Group.paginate :order => 'name', :page => params[:page], :per_page => pages
  end
  
end
